home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / QuickTime VR / MacOS / QuickDraw™ 3D 1.0.6F4 SDK / Development / RAVE DDK 1.0.6 GM for MacOS / Projects / Empty Engine Code / TtTinselTown.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-30  |  10.5 KB  |  366 lines  |  [TEXT/MPCC]
  1. /******************************************************************************
  2.  **                                                                             **
  3.  **     Module:        TtTinselTown.c                                             **
  4.  **                                                                          **
  5.  **     Purpose:     Sample empty drawing engine.                             **
  6.  **                 This module contains registration methods.                 **
  7.  **                                                                          **
  8.  **     Author:        Mike W. Kelley                                             **
  9.  **                                                                          **
  10.  **                    2/3/95    Revised for 0.9 SDK release                         **
  11.  **                                                                          **
  12.  **     Copyright (C) 1994-95 Apple Computer, Inc.  All rights reserved.     **
  13.  **     Apple Computer Confidential                                             **
  14.  **                                                                          **
  15.  *****************************************************************************/
  16.  
  17. /* System */
  18. #include <stdio.h>
  19. #include <stdlib.h>
  20. #include <string.h>
  21.  
  22. #include "Drive3D.h"
  23. #include "Drive3D_system.h"
  24. #include "TtTinselTown.h"
  25.  
  26. /************************************************************************************************
  27.  * Globals.
  28.  ***********************************************************************************************/
  29.  
  30. TTtStorePrivate        gTtStorePrivate = { NULL, NULL };
  31.  
  32. /************************************************************************************************
  33.  * Error handling stuff.
  34.  ***********************************************************************************************/
  35.  
  36. #ifdef kTtDebug
  37.     void TtError (
  38.         const char        *message)
  39.     {
  40.         char    ErrorStr[255];
  41.         
  42.         strcpy (&ErrorStr[1], message);
  43.         ErrorStr[0] = strlen (message);
  44.         DebugStr ( (ConstStr255Param) ErrorStr);
  45.     }
  46. #endif
  47.  
  48. /************************************************************************************************
  49.  * Create the private draw context data.
  50.  ***********************************************************************************************/
  51.  
  52. TQAError TtDrawPrivateNew (
  53.     TQADrawContext        *newDrawContext,    /* Draw context to initialize */
  54.     const TQADevice        *device,            /* Target device */
  55.     const TQARect        *rect,                /* Target rectangle (device coordinates) */
  56.     const TQAClip        *clip,                /* 2D clip region (or NULL) */
  57.     unsigned long        flags)                /* Mask of kQAContext_xxx */
  58. {
  59.     TTtDrawPrivate        *newDrawPrivate;
  60.     long                width, height;
  61.     
  62.     /*
  63.      * Allocate the TTtDrawPrivate structure.
  64.      */
  65.     
  66.     newDrawPrivate = TtMemoryNew (sizeof (TTtDrawPrivate));
  67.     
  68.     if (newDrawPrivate == NULL)
  69.     {
  70.         return (kQAParamErr);
  71.     }
  72.     
  73.     newDrawPrivate->flags = flags;
  74.     newDrawPrivate->device = *device;
  75.     newDrawPrivate->deviceRect = *rect;
  76.     
  77.     /*
  78.      * Initialize the fields that describe the front (visible) buffer.
  79.      */
  80.     
  81.     newDrawPrivate->width = width = rect->right - rect->left;
  82.     newDrawPrivate->height = height = rect->bottom - rect->top;
  83.     
  84.     switch (device->deviceType)
  85.     {
  86.         case kQADeviceMemory:
  87.             newDrawPrivate->rowBytes = device->device.memoryDevice.rowBytes;
  88.             switch (device->device.memoryDevice.pixelType)
  89.             {
  90.                 case kQAPixel_ARGB16:
  91.                     newDrawPrivate->depth = 16;
  92.                     break;
  93.                 
  94.                 case kQAPixel_ARGB32:
  95.                     newDrawPrivate->depth = 32;
  96.                     break;
  97.                 
  98.                 default:
  99.                     return (kQANotSupported);
  100.                     break;
  101.             }
  102.             newDrawPrivate->baseAddr = ((char *) device->device.memoryDevice.baseAddr)
  103.                     + rect->left * (newDrawPrivate->depth >> 3)
  104.                     + rect->top * newDrawPrivate->rowBytes;
  105.             break;
  106.         
  107.         case kQADeviceGDevice:
  108.             {
  109.                 PixMap            *devicePixMap;
  110.                 
  111.                 devicePixMap = *(*device->device.gDevice)->gdPMap;
  112.                 
  113.                 newDrawPrivate->rowBytes = devicePixMap->rowBytes & 0x3fff;
  114.                 newDrawPrivate->depth = devicePixMap->pixelSize;
  115.                 newDrawPrivate->baseAddr = devicePixMap->baseAddr
  116.                     + rect->left * (newDrawPrivate->depth >> 3)
  117.                     + rect->top * newDrawPrivate->rowBytes;
  118.             }
  119.             break;
  120.         
  121.         #ifdef kTtDebug
  122.             default:
  123.                 TtError ("Unknown TQADevice type");
  124.                 break;
  125.         #endif
  126.     }
  127.     
  128.     /*
  129.      * If a clip region is assigned, copy it into the private data.
  130.      */
  131.     
  132.     if (clip)
  133.     {
  134.         switch (clip->clipType)
  135.         {
  136.             case kQAClipRgn:
  137.                 {
  138.                     /*
  139.                      * Deal with the clip rgn. Probably the best solution is to
  140.                      * draw it into a 1 bit/pixel bitmap and use that as a write
  141.                      * mask.
  142.                      */
  143.                 }
  144.                 break;
  145.             
  146.             #ifdef kTtDebug
  147.                 default:
  148.                     TtError ("Unknown TQAClip type");
  149.                     break;
  150.             #endif
  151.         }
  152.     }
  153.     
  154.     /*
  155.      * Set the default state variable values.
  156.      */
  157.     
  158.     newDrawPrivate->state [kQATag_ZFunction].i =
  159.             (flags & kQAContext_NoZBuffer) ? kQAZFunction_None : kQAZFunction_LT;
  160.     newDrawPrivate->state [kQATag_ColorBG_a].f = 0.0;
  161.     newDrawPrivate->state [kQATag_ColorBG_r].f = 0.0;
  162.     newDrawPrivate->state [kQATag_ColorBG_g].f = 0.0;
  163.     newDrawPrivate->state [kQATag_ColorBG_b].f = 0.0;
  164.     newDrawPrivate->state [kQATag_Width].f = 1.0;
  165.     newDrawPrivate->state [kQATag_ZMinOffset].f = 0.0;
  166.     newDrawPrivate->state [kQATag_ZMinScale].f = 1.0 / 65535.0;    /* Engine-specific */
  167.     
  168.     /*
  169.      * Set the state variables used for texture mapping, etc. (and clear unused ones).
  170.      */
  171.     
  172.     newDrawPrivate->state [kQATag_Antialias].i = kQAAntiAlias_Fast;
  173.     newDrawPrivate->state [kQATag_Blend].i = kQABlend_PreMultiply;
  174.     newDrawPrivate->state [kQATag_PerspectiveZ].i = kQAPerspectiveZ_Off;
  175.     newDrawPrivate->state [kQATag_TextureFilter].i = kQATextureFilter_Fast;
  176.     newDrawPrivate->state [kQATag_TextureOp].i = kQATextureOp_None;
  177.     newDrawPrivate->state [kQATag_Texture].i = 0;
  178.  
  179.     /*
  180.      * Initialize the TQADrawContext methods and draw private pointer, and return.
  181.      * Note that we don't initialize the 
  182.      */
  183.     
  184.     newDrawContext->drawPrivate = (TQADrawPrivate *) newDrawPrivate;
  185.     newDrawContext->setFloat = TtSetFloat;
  186.     newDrawContext->setInt = TtSetInt;
  187.     newDrawContext->setPtr = TtSetPtr;
  188.     newDrawContext->getFloat = TtGetFloat;
  189.     newDrawContext->getInt = TtGetInt;
  190.     newDrawContext->getPtr = TtGetPtr;
  191.     newDrawContext->drawPoint = TtDrawPoint;
  192.     newDrawContext->drawLine = TtDrawLine;
  193.     newDrawContext->drawTriGouraud = TtDrawTriGouraud;
  194.     newDrawContext->drawTriTexture = TtDrawTriTexture;
  195.     newDrawContext->drawBitmap = TtDrawBitmap;
  196.     newDrawContext->renderStart = TtRenderStart;
  197.     newDrawContext->renderEnd = TtRenderEnd;
  198.     newDrawContext->renderAbort = TtRenderAbort;
  199.     newDrawContext->flush = TtFlush;
  200.     newDrawContext->sync = TtSync;
  201.     
  202.     return (kQANoErr);
  203. }
  204.  
  205. /************************************************************************************************
  206.  * Delete private draw context data.
  207.  ***********************************************************************************************/
  208.  
  209. void TtDrawPrivateDelete (
  210.     TQADrawPrivate        *drawPrivate)        /* Private context data to delete */
  211. {
  212.     TTtDrawPrivate        *myPrivate;
  213.  
  214.     myPrivate = (TTtDrawPrivate *) drawPrivate;
  215.     
  216.     TtMemoryDelete (myPrivate);
  217. }
  218.  
  219. /************************************************************************************************
  220.  * Return kQANoErr if we can draw to 'device'. For example, this code causes
  221.  * this drawing engine to be used for only 16 and 32 bit/pixel devices.
  222.  ***********************************************************************************************/
  223.  
  224. TQAError TtEngineDeviceCheck (
  225.     const TQADevice    *device)                /* Target device */
  226. {
  227.     if (device->deviceType == kQADeviceMemory)
  228.     {
  229.         TQAImagePixelType        targetPixelType;
  230.     
  231.         targetPixelType = device->device.memoryDevice.pixelType;
  232.         return (((targetPixelType == kQAPixel_ARGB16) || (targetPixelType == kQAPixel_ARGB32))
  233.                 ? kQANoErr : kQAError);
  234.     }
  235.     else if (device->deviceType == kQADeviceGDevice)
  236.     {
  237.         long                    targetDepth;
  238.     
  239.         targetDepth = (*(*device->device.gDevice)->gdPMap)->pixelSize;
  240.         return (((targetDepth == 16) || (targetDepth == 32)) ? kQANoErr : kQAError);
  241.     }
  242.     
  243.     return (kQAError);
  244. }
  245.  
  246. /************************************************************************************************
  247.  * This function returns gestalt information about this engine to the application.
  248.  ***********************************************************************************************/
  249.  
  250. TQAError TtEngineGestalt (
  251.     TQAGestaltSelector    selector,            /* Gestalt parameter being requested */
  252.     void                *response)            /* Buffer that receives response */
  253. {
  254.     const char            *TtName = "Empty Drawing Engine";
  255.     const char            *source;
  256.     char                *target;
  257.     long                length;
  258.     
  259.     switch (selector)
  260.     {
  261.         case kQAGestalt_OptionalFeatures:
  262.             *((unsigned long *) response) = kQAOptional_None;
  263.             break;
  264.         
  265.         case kQAGestalt_FastFeatures:
  266.             *((unsigned long *) response) = kQAFast_None;
  267.             break;
  268.         
  269.         case kQAGestalt_VendorID:
  270.             *((long *) response) = kTtMyVendorID;
  271.             break;
  272.         
  273.         case kQAGestalt_EngineID:
  274.             *((long *) response) = kTtMyEngineID;
  275.             break;
  276.         
  277.         case kQAGestalt_Revision:
  278.             *((long *) response) = kTtMyRevisionID;
  279.             break;
  280.         
  281.         case kQAGestalt_ASCIINameLength:
  282.             for (source = TtName, length = 0; *source++; /* Nothing */)
  283.             {
  284.                 ++length;
  285.             }
  286.             *((long *) response) = length;
  287.             break;
  288.         
  289.         case kQAGestalt_ASCIIName:
  290.             for (source = TtName, target = (char *) response; *source; /* Nothing */)
  291.             {
  292.                 *target++ = *source++;
  293.             }
  294.             *target = '\0';
  295.             break;
  296.         
  297.         default:
  298.             return (kQAGestaltUnknown);
  299.             break;
  300.     }
  301.     
  302.     return (kQANoErr);
  303. }
  304.  
  305. /************************************************************************************************
  306.  * This function is called by the manager to get our engine methods.
  307.  ***********************************************************************************************/
  308.  
  309. static TQAError TtEngineGetMethod (
  310.     TQAEngineMethodTag        methodTag,                /* Method being requested */
  311.     TQAEngineMethod            *method)                /* (Out) Method */
  312. {
  313.     switch (methodTag)
  314.     {
  315.         case kQADrawPrivateNew:
  316.             method->drawPrivateNew = TtDrawPrivateNew;
  317.             break;
  318.         case kQADrawPrivateDelete:
  319.             method->drawPrivateDelete = TtDrawPrivateDelete;
  320.             break;
  321.         case kQAEngineCheckDevice:
  322.             method->engineCheckDevice = TtEngineDeviceCheck;
  323.             break;
  324.         case kQAEngineGestalt:
  325.             method->engineGestalt = TtEngineGestalt;
  326.             break;
  327.         case kQATextureNew:
  328.             method->textureNew = TtTextureNew;
  329.             break;
  330.         case kQATextureDetach:
  331.             method->textureDetach = TtTextureDetach;
  332.             break;
  333.         case kQATextureDelete:
  334.             method->textureDelete = TtTextureDelete;
  335.             break;
  336.         case kQABitmapNew:
  337.             method->bitmapNew = TtBitmapNew;
  338.             break;
  339.         case kQABitmapDetach:
  340.             method->bitmapDetach = TtBitmapDetach;
  341.             break;
  342.         case kQABitmapDelete:
  343.             method->bitmapDelete = TtBitmapDelete;
  344.             break;
  345.         default:
  346.             return (kQAParamErr);
  347.             break;
  348.     }
  349.     return (kQANoErr);
  350. }
  351.  
  352. /************************************************************************************************
  353.  * Call this function to register this rasterizer with Tinsel Town. This is usually
  354.  * called by the shared library initialization method. This function returns 0 on success,
  355.  * non-zero on error.
  356.  ***********************************************************************************************/
  357.  
  358. OSErr TtRegister (void)
  359. {
  360.     TQAError    status;
  361.     
  362.     status = QARegisterEngine (TtEngineGetMethod);
  363.     
  364.     return ((status == kQANoErr) ? noErr : paramErr);
  365. }
  366.